home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / muds / lpmud312.tar / lpmud312 / parse_old.c < prev    next >
C/C++ Source or Header  |  1992-01-11  |  27KB  |  1,054 lines
  1. /*
  2.  
  3.   Pattern Parser package for LPmud, JnA 1990
  4.  
  5.   Ver 2.0
  6.  
  7.   If you have questions or complaints about this code please refer them
  8.   to jna@cd.chalmers.se
  9.  
  10.   This is the old version of parse_command() used in compatibility mode.
  11.  
  12. */
  13.  
  14. #include <stdio.h>
  15. #include <string.h>
  16. #include <ctype.h>
  17. #include <time.h>
  18. #include "lint.h"
  19. #include "interpret.h"
  20. #include "config.h"
  21. #include "object.h"
  22. #include "wiz_list.h"
  23.  
  24. #define VALUE struct svalue
  25. #define OBJECT struct object
  26. #define VECTOR struct vector
  27. #define SVALUE struct svalue
  28. #define LVALUE struct svalue
  29.  
  30. extern char *string_copy PROT((char *)), *xalloc PROT((int));
  31. extern int o_flag, d_flag; /* for debugging purposes */
  32. extern SVALUE const0, const1;
  33.  
  34. #ifndef tolower            /* On some systems this is a function */
  35. extern int tolower PROT((int));
  36. #endif
  37.  
  38. #ifdef COMPAT_MODE
  39. /*****************************************************
  40.  
  41.   This is the parser
  42.  
  43.  
  44.   Left to do 910723:
  45.  
  46.   Fix so alternatives possible after %s in a pattern 
  47.  
  48. */
  49. /*
  50.   Doc for LPC function
  51.  
  52. int parse_command(string,ob/arr,string,destargs...)
  53.  
  54.     parse        Returns 1 if pattern matches
  55.  
  56.     string        Given command
  57.     ob/arr        if arr 
  58.                 array holding the accessible objects
  59.             if ob
  60.                 object from which to recurse and create
  61.                 the list of accessible objects, normally
  62.                 ob = environment(this_player())
  63.     string        Parsepattern as list of words and formats:
  64.             Example string = " 'get' / 'take' %i "
  65.             Syntax:
  66.                 'word'         obligatory text
  67.                 [word]        optional text
  68.                 /        Alternative marker
  69.                 %o        Single item, object
  70.                 %l        Single living object
  71.                 %s        Any text
  72.                 %w              Any word
  73.                 %p        Preposition
  74.                 %i        Any items
  75.                 %d              Number 0- or tx(0-99)
  76.  
  77.     destargs    This is the list of result variables as in sscanf
  78.             One variable is needed for each %_
  79.             The return types of different %_ is:
  80.             %o    Returns an object
  81.             %l    Returns an object
  82.             %s    Returns a string of words
  83.             %w      Returns a string of one word
  84.             %p    Can on entry hold a list of word in array
  85.                 or an empty variable
  86.                 Returns:
  87.                    if empty variable: a string
  88.                    if array: array[0]=matched word
  89.             %i    Returns a special array on the form:
  90.                 [0] = (int) +(wanted) -(order) 0(all)
  91.                 [1..n] (object) Objectpointers
  92.             %d      Returns a number
  93.             
  94. Example:
  95.  
  96.  parse_command("take apple",environment(this_player()),
  97.  " 'get' / 'take' %i ",items);
  98.  
  99.  
  100. */ 
  101.  
  102. /* Hardcoded function names to call in LPC objects
  103. */
  104. #define QIDFUNC "id"                /* Func to query in objects to ack name */
  105. #define QPLURIDFUNC "plural_id"     /* As Id but pluralform of name */
  106. #define QADJFUNC "adjectiv_id"      /* As Id but ack adjectiv not name */
  107. #define QSHORTFUNC "short"          /* Objects shortdescription */
  108.  
  109. #define EQ(x,y) (strcmp(x,y)==0)
  110. #define EQN(x,y) (strncmp(x,y,strlen(x))==0)
  111. #define EMPTY(x) (strcmp(x,"")==0)
  112. #define COPY(x) (strcpy((char*)xalloc(strlen(x)+1),x))
  113.  
  114. #define KLUDGELEN   200            /* How long should strings be */
  115.  
  116. struct altern_objects {
  117.   OBJECT *ao_obj;
  118.   struct altern_objects *next;
  119. };
  120.  
  121. int gDebug=0;
  122. char gMword[KLUDGELEN];            /* Text inom '' och [] */
  123. char gFword[KLUDGELEN];            /* Temp word gotten by getfirst() */
  124. struct altern_objects *gOblist;    /* List of accessible objects */
  125. char gAdjective[4*KLUDGELEN];      /* all adjectives before objname */
  126. LVALUE *gCarg;                     /* Current argument to %_ */
  127. int gWantnum;                      /* Number of wanted items 0 = all */
  128. struct altern_objects *gPobjects;  /* List of parsed objects */
  129. LVALUE *gTxarg;                    /* Argument of LPCvariable to store %s  */
  130. LVALUE *gForprepos;                /* Save arg* here for findprepos */
  131. LVALUE *gTopStack;                 /* arg* to arg after my last */
  132.  
  133. #define EP 0          /* End Parse marker */
  134. #define SI 1          /* %o single item */
  135. #define IT 2          /* %i  items */
  136. #define US 3          /* %l  single living object */
  137. #define PP 4          /* %p  prepositions */
  138. #define TX 5          /* %s  string of words */
  139. #define DTX 6         /* 'word' */
  140. #define OTX 7         /* [word] */
  141. #define ALT 8         /* /   alternates */
  142. #define W1 9          /* %w  string of one word */
  143. #define NUM 10        /* %d  integer */
  144.  
  145. /* Search string in reverse order, I should replace it with strrchr I know :)
  146. */
  147. char *backstrchr (apa, ch)
  148.     char *apa;
  149.     char ch;
  150. {
  151.   char *sp;
  152.  
  153.   sp = &apa[strlen(apa)];
  154.   while (sp>apa) {
  155.     if (*sp==ch) return sp+1;
  156.     sp--;
  157.   }
  158.   return 0;
  159. }
  160.  
  161. /* Convert string to lowercase
  162. */
  163. char *lowercase (apa)
  164.     char *apa;
  165. {
  166.   char *bepa;
  167.  
  168.   bepa = apa;
  169.   while (*bepa) {
  170.     if ((*bepa>'A') && (*bepa<'a')) (*bepa)+='a'-'A';
  171.     bepa++;
  172.   }
  173.   return apa;
  174. }
  175.  
  176. /* Add all objects in the inventory of 'first' and itself to the list 'parent'
  177.    antal holds the number of elements in the 'parent' list.
  178. */
  179. void fixlist (first, parent, antal)
  180.     OBJECT *first;
  181.     struct altern_objects **parent;
  182.     int *antal;
  183. {
  184.   OBJECT *cur;
  185.   struct altern_objects *this,*taill;
  186.   cur=first; this= *parent;
  187.   if (!cur) return;
  188.   while (cur) {
  189.     if (cur->contains) fixlist(cur->contains,&this,antal);
  190.     taill=this;
  191.     this=(struct altern_objects *) xalloc(sizeof(struct altern_objects));
  192.     this->ao_obj=cur; (*antal)++;
  193.     add_ref(cur,"parse->fixlist");
  194.     if (gDebug) fprintf(stderr," Obj:%s ,",cur->name);
  195.     this->next=taill; cur=cur->next_inv;
  196.   }
  197.   *parent=this;
  198. }
  199.  
  200. /* Create a list of the theoretically accessible objects from 'src'
  201. */
  202. int makeobjlist (alist, src)
  203.     struct altern_objects **alist;
  204.     OBJECT *src;
  205. {
  206.   OBJECT *env,*cur;
  207.   struct altern_objects *this;
  208.   int cnt;
  209.   *alist=0;
  210.   if (!src) env=command_giver->super;
  211.   else env=src;
  212.   if (!env) return 0;
  213.   if (gDebug) fprintf(stderr,"Make list: %s\n",env->name);
  214.   if (!(env->contains)) return 0;
  215.   cur=env->contains;
  216.   this=0; cnt=0;
  217.   fixlist(cur,&this,&cnt); *alist=this;
  218.   return cnt;
  219. }
  220.  
  221. /* Routines to use for alternate filters
  222. */
  223.  
  224. /* Return number of objects in the list
  225. */
  226. int itnumalt()
  227. { 
  228.   int ant;
  229.   struct altern_objects *ao;
  230.  
  231.   ant=0; ao=gPobjects;
  232.   while (ao) {
  233.     ant++;
  234.     ao=ao->next;
  235.   }
  236.   return ant;
  237. }
  238.  
  239. /* Return a pointer to the numbered element of the list
  240. */ 
  241. OBJECT *italt (a)
  242.     int a;
  243. { 
  244.   int ant;
  245.   struct altern_objects *ao;
  246.  
  247.   ant=0; ao=gPobjects;
  248.   while (ao) {
  249.     ant++;
  250.     if (ant==a) return ao->ao_obj;
  251.     ao=ao->next;
  252.   }
  253.   return 0;
  254. }
  255.  
  256. /* Free the list, parameter bas is obsolete
  257. */
  258. void italt_new ()
  259. {
  260.  
  261.   /* Free p} altern_objects listan */
  262.   struct altern_objects *ao;
  263.   struct altern_objects *ao2;
  264.  
  265.   if (gDebug) fprintf(stderr,"Clearing italt\n");
  266.   ao2=ao=gPobjects; gPobjects=0;
  267.   while (ao) {
  268.     ao=ao->next;
  269.     free_object(ao2->ao_obj,"parse->italt_new()");
  270.     free((char *)ao2); 
  271.     ao2=ao;
  272.   }
  273. }
  274.  
  275. /* Create the list as all the theoretically accessible objects
  276. */
  277. void italt_loadall()
  278. {
  279.   if (gPobjects) italt_new();
  280.   makeobjlist(&gPobjects,0);
  281. }
  282.  
  283. /* Put an object at the end of the list
  284. */
  285. void italt_put (obj)
  286.     OBJECT *obj;
  287. {
  288.   struct altern_objects *ao,*old;
  289.  
  290.   if (gDebug) fprintf(stderr,"Putting: %s",obj->name);
  291.   ao=gPobjects; old=ao;
  292.   while (ao) {
  293.     old=ao; ao=ao->next;
  294.   }
  295.   ao=(struct altern_objects *) xalloc(sizeof(struct altern_objects));
  296.   if (old) old->next=ao; 
  297.   else gPobjects=ao;
  298.   ao->ao_obj=obj; ao->next=0;
  299.   add_ref(obj,"parse->italt_put()");
  300.   if (gDebug) fprintf(stderr,"..done\n");
  301. }
  302.  
  303.  
  304. /* Put first word of cmd in gFword and point to next word
  305. */
  306. char *getfirst (cmd)
  307.     char **cmd;
  308. {
  309.   int pos,inqoute;
  310.   char ch,*st;
  311.  
  312.   st= *cmd; strcpy(gFword,""); if (st[0]==0) return gFword;
  313.   ch=' '; pos=0; inqoute=0; 
  314.   while ((st[0]<=' ') && (st[0])) st++; /* Skip leading spaces */
  315.   if ((st[0]=='\'') || (st[0]=='[')) {
  316.     inqoute=1; ch=st[0]; gFword[0]=st[0]; pos=1; st++;
  317.   }
  318.   if (ch=='[') ch=']';
  319.   while ((pos<(KLUDGELEN-1)) && (st[0]) && (st[0]!=ch)) {
  320.     gFword[pos++]=st[0]; st++;
  321.     if ((st[0]) && (st[0]<' ')) st[0]=' ';  /* Replace ctrl chars */
  322.   }
  323.   if ((inqoute) && (pos<(KLUDGELEN-1))) {
  324.     gFword[pos++]=ch; if (st[0]) st++;
  325.   }
  326.   gFword[pos]=0;  /* fprintf(stderr,"{%s}",gFword); */
  327.   *cmd=st;
  328.   return gFword;
  329. }
  330.  
  331. /* Put first word of cmd in gFword
  332.    without incrementing the callers pointer in the command string
  333. */
  334. char *lookfirst (cmd)
  335.     char *cmd;
  336. {
  337.   return getfirst(&cmd);
  338. }     
  339.  
  340. /* Call object function in LPC
  341. */
  342. int call_obj (fnamn, on, apa)
  343.     char *fnamn;
  344.     OBJECT *on;
  345.     char *apa;
  346. {
  347.   struct svalue *ret;
  348.   
  349.   if (gDebug) fprintf(stderr,"Calling %s in %s with %s\n",fnamn,on->name,apa);
  350.   push_constant_string(apa);
  351.   ret = apply(fnamn,on,1);
  352.   if (!ret) return 0;
  353.   if ( ret->type == T_NUMBER) return ret->u.number;
  354.   return 0;
  355. }
  356.  
  357. /* Change a noun in pluralform to a noun in singularform
  358. */
  359. char *singfix (str)
  360.     char *str;
  361. {
  362.   static char sing[KLUDGELEN];
  363.   char *sp;
  364.   int sl;
  365.  
  366.   sl=strlen(str); if (sl<2) return str;
  367.   sp= &str[sl-3]; strcpy(sing,str); sing[sl-3]=0;
  368.   if (gDebug) fprintf(stderr,"To singular (%s) end(%s) begin(%s)\n",str,sp,sing);
  369.   if (EQ(str,"corpses")) return "corpse";
  370.   if (EQ(sp,"ses")) return strcat(sing,"s");
  371.   else if (EQ(sp,"xes")) return strcat(sing,"x");
  372.   else if (EQ(sp,"hes")) return strcat(sing,"h");
  373.   else if (EQ(sp,"ies")) return strcat(sing,"y");
  374.   else if (EQ(sp,"ves")) return strcat(sing,"fe");
  375.   else if (sp[2]=='s') {
  376.     strcat(sing,sp); sing[sl-1]=0;
  377.     return sing;
  378.   }
  379.   if (EQ(str,"teeth")) return "tooth";
  380.   if (EQ(str,"feet")) return "foot";
  381.   if (EQ(str,"men")) return "man";
  382.   if (EQ(str,"women")) return "woman";
  383.   if (EQ(str,"children")) return "child";
  384.   if (EQ(str,"sheep")) return "sheep";
  385.   return str;
  386. }
  387.     
  388. /* Checks with obj in gOblist to see if it accepts all gAdjectives in adjs
  389.    Used when name of object not known, i.e cmds like: 'get all the red ones'
  390.    if func QADJFUNC doesn't exist in obj last word of QSHORTFUNC is used
  391.    as object name and set as suffix to the adjective in call to id()
  392. */
  393. int matchadjective (adjs)
  394.     char *adjs;
  395. {
  396.  
  397.   char ad[KLUDGELEN],tot[2*KLUDGELEN],*sp,*sp2;
  398.   struct altern_objects *ao;
  399.   OBJECT *on;
  400.   struct svalue *ret;
  401.  
  402.   ao=gOblist;
  403.   while (ao) {
  404.     on=ao->ao_obj;
  405.     sp=adjs;
  406.     while ((on) && (sp) && (*sp)) {
  407.       while (*sp==' ') sp++;
  408.       sp2=strchr(sp,' ');  
  409.       if (sp2) {
  410.     *sp2=0;
  411.     strcpy(ad,sp); *sp2=' '; sp=sp2;
  412.     if (!call_obj(QADJFUNC,on,ad)) on=0; /* Not ok */
  413.       }
  414.       sp=sp2;
  415.     }
  416.     if (on) italt_put(on);
  417.     else {
  418.       on=ao->ao_obj;
  419.       ret = apply(QSHORTFUNC,on,0);
  420.       if (ret->type==T_STRING) {
  421.     sp=ret->u.string; sp2=backstrchr(sp,' ');
  422.     if (sp2) sp=sp2;
  423.     sprintf(tot,"%s%s",adjs,sp); lowercase(tot);
  424.     if (!call_obj(QIDFUNC,on,tot)) on=0;
  425.       }
  426.       else on=0;
  427.     }
  428.     if (on) italt_put(on);
  429.     ao=ao->next;
  430.   }
  431.   return itnumalt();
  432. }
  433.  
  434. /* Decide if a word is a general word of type: those, ones
  435. */
  436. int check_for_general (onam, plur)
  437.     char *onam;
  438.     int plur;
  439. {
  440.  
  441.   static char* plurpron[] = {"those","them","these","ones","$"};
  442.   static char* singpron[] = {"this","one","it","$"};
  443.   int ilop;
  444.   
  445.   if (EMPTY(onam)) return 0;
  446.   if (plur) {
  447.     ilop=0; 
  448.     while (!EQ(plurpron[ilop],"$")) if (EQ(plurpron[ilop++],onam)) return 1;
  449.   }
  450.   else {
  451.     ilop=0; 
  452.     while (!EQ(singpron[ilop],"$")) if (EQ(singpron[ilop++],onam)) return 1;
  453.   }
  454.   return 0;
  455. }
  456.  
  457. int order_num (wd)
  458.     char *wd;
  459. { /* Only positive numbers and zero */
  460.  
  461.   static char *onums[] = {"first","second","third","fourth","fifth","sixth",
  462.           "seventh","eighth","nineth","tenth",
  463.           "eleventh","twelfth","thirteenth","fourteenth","fifteenth","sixteenth",
  464.           "seventeenth","eighteenth","nineteenth","dummy"};
  465.   static char *onumt[] = {"twenty","thirty","forty","fifty","sixty","seventy",
  466.           "eighty","ninety"};
  467.   static char *onumta[] = {"twentieth","thirtieth","fortieth","fiftieth","sixtieth","seventieth",
  468.           "eightieth","ninetieth"};
  469.  
  470.   char ns[KLUDGELEN];
  471.  
  472.   int ilop,nm;
  473.  
  474.   if (EMPTY(wd)) return -1;
  475.   for (ilop=1;ilop<20;ilop++) {
  476.     if (EQ(onums[ilop-1],wd)) return ilop;
  477.   }
  478.   for (nm=0;nm<8;nm++) for (ilop=0;ilop<9;ilop++) {
  479.     if (ilop>0) {
  480.     sprintf(ns,"%s%s",onumt[nm],onums[ilop-1]);
  481.     if (EQ(ns,wd)) return 20+nm*10+(ilop);
  482.     } else
  483.     if (EQ(onumta[nm],wd)) return 20+nm*10+(ilop);
  484.   }
  485.   return -1;
  486. }
  487.  
  488. int numeric (wd)
  489.     char *wd;
  490. { /* Only positive numbers and zero */
  491.  
  492.   static char *nums[] = {"one","two","three","four","five","six",
  493.           "seven","eight","nine","ten",
  494.           "eleven","twelve","thirteen","fourteen","fifteen","sixteen",
  495.           "seventeen","eighteen","nineteen"};
  496.   static char *numt[] = {"twenty","thirty","forty","fifty","sixty","seventy",
  497.           "eighty","ninety"};
  498.  
  499.   char ns[KLUDGELEN];
  500.  
  501.   int ilop,nm;
  502.  
  503.   if (EMPTY(wd)) return -1;
  504.   if (sscanf(wd,"%d",&nm)) return (nm>=0) ? nm : -1;
  505.   if ((EQ(wd,"a")) || (EQ(wd,"an"))) return 1;
  506.   for (ilop=1;ilop<20;ilop++) if (EQ(nums[ilop-1],wd)) return ilop;
  507.   for (nm=0;nm<8;nm++) for (ilop=0;ilop<9;ilop++) {
  508.     if (ilop>0) {
  509.     sprintf(ns,"%s%s",numt[nm],nums[ilop-1]);
  510.     if (EQ(ns,wd)) return 20+nm*10+(ilop);
  511.     }
  512.     else
  513.     if (EQ(numt[nm],wd)) return 20+nm*10+(ilop);
  514.   }
  515.   return -1;
  516. }
  517.  
  518. /* Searches commandstring for "adj1 adj2 ... adjN objectname"
  519.    Stores words before name in string: gAdjective, as "adj1 adj2 adj3 "
  520. */
  521. OBJECT *matchobject2 (cmd, plur)
  522.     char **cmd;
  523.     int plur;
  524. { 
  525.   OBJECT *on;
  526.   struct altern_objects *ao;
  527.   char *st,*ocmd,totname[2*KLUDGELEN],tot2[2*KLUDGELEN];
  528.  
  529.   ocmd= *cmd; strcpy(gAdjective,"");
  530.   st=lowercase(getfirst(cmd)); 
  531.   while (st[0]) {
  532.     if (check_for_general(st,plur)) {
  533.       if (matchadjective(gAdjective)) return italt(1);
  534.     }
  535.     sprintf(totname,"%s%s",gAdjective,st);
  536.     if (plur) sprintf(tot2,"%s%s",gAdjective,singfix(st));
  537.     ao=gOblist; 
  538.     while (ao) {
  539.       on=0;
  540.       if (plur) {
  541.     if (call_obj(QPLURIDFUNC,ao->ao_obj,totname)) on=ao->ao_obj;
  542.     else if (call_obj(QIDFUNC,ao->ao_obj,tot2)) on=ao->ao_obj;
  543.       }
  544.       else if (call_obj(QIDFUNC,ao->ao_obj,totname)) on=ao->ao_obj;
  545.       if (on) italt_put(on);
  546.       ao=ao->next;
  547.     }
  548.     if (!itnumalt()) {
  549.       strcat(gAdjective,st); strcat(gAdjective," ");
  550.       st=lowercase(getfirst(cmd)); 
  551.     }
  552.     else st[0]=0;
  553.   }
  554.   if (itnumalt()) return italt(1);
  555.   *cmd=ocmd; return 0;
  556. }
  557.  
  558. /* Search the command for valid object description
  559. */
  560. OBJECT *finditem (cmd, plur)
  561.     char **cmd;
  562.     int plur;
  563. { 
  564.   int nm;
  565.   OBJECT *pn;
  566.   char *ocmd,w1[KLUDGELEN];
  567.   
  568.   ocmd= *cmd; strcpy(w1,lowercase(getfirst(cmd)));
  569.   if (gDebug) fprintf(stderr,"FO (plur=%d): %s\n",plur,ocmd);
  570.   italt_new(); /* Clear alternate list */
  571.   gWantnum=1; /* Antal objekt som anv{ndaren vill ta */
  572.   if (EMPTY(w1)) {
  573.     *cmd=ocmd;
  574.     return 0;
  575.   }
  576.  
  577.   /* Must be hardcode skipped for recursive with plural
  578.    */
  579.   if (EQ("the",w1)) {
  580.     if (gDebug) fprintf(stderr,"Skip 'the'\n");
  581.     *cmd=ocmd; getfirst(cmd); 
  582.     if ((pn=finditem(cmd,plur))) return pn;
  583.     else { *cmd=ocmd; return 0; }
  584.   }
  585.   
  586.   /* Check things like: some <objname>
  587.    */
  588.   else if ((EQ("some",w1)) && (plur==0)) {
  589.     *cmd=ocmd; getfirst(cmd);
  590.     /* Skip of in : some of the bottles */
  591.     if (EQ(lowercase(lookfirst(*cmd)),"of")) getfirst(cmd);
  592.  
  593.     nm = random_number(6) + 2; /* some objects are random:2-7 */
  594.     if (gDebug) fprintf(stderr,"some rnd = %d\n",nm);
  595.     if ((pn=finditem(cmd,1))) { 
  596.       gWantnum=nm; 
  597.       return pn; 
  598.     }
  599.   }
  600.   
  601.   /* Check things like: three <objname>
  602.    */
  603.   else if ( (plur==0) && ((nm=numeric(w1))>0) ) {
  604.     if (gDebug) fprintf(stderr,"Numeral: %d (%s)\n",nm,w1);
  605.     *cmd=ocmd; getfirst(cmd);
  606.     /* Skip of in : two of the bottles */
  607.     if (EQ(lowercase(lookfirst(*cmd)),"of")) getfirst(cmd);
  608.     if ((pn=finditem(cmd,nm-1))) {
  609.       gWantnum=nm; return pn;
  610.     }
  611.   }
  612.   
  613.   /* Check things like: third <objname>
  614.    */
  615.   else if ( (plur==0) && ((nm=order_num(w1))>0) ) {
  616.     if (gDebug) fprintf(stderr,"Order: %d (%s)\n",nm,w1);
  617.     *cmd=ocmd; getfirst(cmd);
  618.     /* Skip of in : second of the bottles */
  619.     if (EQ(lowercase(lookfirst(*cmd)),"of")) {
  620.       getfirst(cmd);
  621.       if ((pn=finditem(cmd,1))) { /* Fix second of the bottles */
  622.     gWantnum= -nm; return pn;
  623.       }
  624.     }
  625.     else {
  626.       if ((pn=finditem(cmd,0))) { /* Fix second bottle */
  627.     gWantnum = -nm; return pn;
  628.       }
  629.     }
  630.   }
  631.   
  632.   
  633.   /* Check things like: all <objname>
  634.    */
  635.   else if ((EQ("all",w1)) && (plur==0)) {
  636.     if (gDebug) fprintf(stderr,"All found\n");
  637.     *cmd=ocmd; getfirst(cmd);
  638.     /* Skip of in : all of the bottles */
  639.     if (EQ(lowercase(lookfirst(*cmd)),"of")) { getfirst(cmd); }
  640.     if ((pn=finditem(cmd,1))) { /* Handle: get all apples */
  641.       gWantnum=0; /* Antal objekt som anvandaren vill ta 0 == all */
  642.       return pn;
  643.     }
  644.     else { /* Handle: get all */
  645.       italt_loadall(); pn=(OBJECT *) italt(1); 
  646.       gWantnum=0; /* Antal objekt som anvandaren vill ta 0 == all */
  647.     }
  648.   }
  649.   
  650.   /* Search for: adj1 adj2 ... adjN objectname
  651.    */
  652.   else {
  653.     *cmd=ocmd; if (gDebug) fprintf(stderr,"Objtry: %s\n",ocmd);
  654.     if (plur) pn=matchobject2(cmd,plur);
  655.     else { /* Standard singular */
  656.       pn=matchobject2(cmd,0); 
  657.       if (!pn) { /* Handle things of type: get apples */
  658.     pn=matchobject2(cmd,1); 
  659.     if (pn) gWantnum = 0; /* Default this to all */
  660.       }
  661.     }
  662.     if (gDebug) fprintf(stderr,"Done matchobject in finditem.\n");
  663.   }
  664.   
  665.   if (pn == 0) *cmd=ocmd;
  666.   if (gDebug) fprintf(stderr,"Done finditem.\n");
  667.   return pn;
  668. }
  669.  
  670. /* Find match to a %i in pattern
  671. */
  672. int findobject (cmd)
  673.     char **cmd;
  674. {
  675.   int nm,s;
  676.   OBJECT *ob;
  677.   
  678.   if (finditem(cmd,0)) {
  679.     if (gCarg) {
  680.       VECTOR *p;
  681.       if (gDebug) fprintf(stderr,"Assign array\n");
  682.       nm=itnumalt();
  683.       p=(VECTOR *)allocate_array(nm+1);
  684.       p->item[0].type = T_NUMBER;
  685.       p->item[0].u.number = gWantnum;
  686.  
  687.       /* Make array in reverse order from italt() because
  688.          makeobjlist() has reversed the order on entry
  689.       */
  690.       for (s=1;s<=nm;s++) {
  691.     p->item[s].type = T_OBJECT;
  692.     p->item[s].u.ob = ob = italt(nm+1-s);
  693.     if (!ob) if (gDebug) fprintf(stderr,"No object from italt %d\n",s);
  694.     if (ob) add_ref(ob,"parse_command");
  695.       }
  696.       free_svalue(gCarg->u.lvalue);
  697.       gCarg->u.lvalue->type = T_POINTER;
  698.       gCarg->u.lvalue->u.vec = p;
  699.       gCarg->u.lvalue->u.vec->ref++;
  700.  
  701.       if (gDebug) fprintf(stderr,"Assign array2\n");
  702.     }
  703.     return 1;
  704.   }
  705.   return 0;
  706. }
  707.  
  708. /* Find match to a %l in pattern
  709. */
  710. OBJECT *findplay (cmd)
  711.     char **cmd;
  712. { 
  713.   OBJECT *pn;
  714.   char w1[KLUDGELEN];
  715.  
  716.   strcpy(w1,lowercase(lookfirst(*cmd)));
  717.   /* can be fixed later with call to LPC command_giver->query_real_name() 
  718.   if (EQ(w1,"me")) strcpy(w1,getmyname_jp());
  719.   if (EQ(w1,"myself")) strcpy(w1,getmyname_jp());
  720.   */
  721.   pn=(OBJECT *) find_living_object(w1, 1);  /* Find player by name */
  722.   if (pn) {
  723.     getfirst(cmd); 
  724.     if (gCarg) {
  725.       free_svalue(gCarg->u.lvalue);
  726.       gCarg->u.lvalue->type = T_OBJECT;
  727.       gCarg->u.lvalue->u.ob = pn;
  728.       add_ref(pn, "parse_command(%l)");
  729.     }
  730.   }
  731.   return pn;
  732. }
  733.  
  734. /* Find match to %p in pattern when a list of words has been supplied
  735. */
  736. int findword (cmd, v)
  737.     char **cmd;
  738.     VALUE *v;
  739. {
  740.   char *w;
  741.   VECTOR *p;
  742.   struct svalue sv;
  743.   int cnt,m,f;
  744.  
  745.   w = lookfirst(*cmd); lowercase(w); p=v->u.vec;
  746.   cnt=0; m=p->size; f= -1;
  747.   while (cnt<m) {
  748.     if (p->item[cnt].type == T_STRING) {
  749.       if (strcmp(p->item[cnt].u.string,w)==0) {
  750.     f=cnt; cnt=m;
  751.       }
  752.     }
  753.     cnt+=1;
  754.   }
  755.   if (f<0) return 0;
  756.   getfirst(cmd);
  757.   if (!f) return 1; /* Match and word in first element */
  758.   /*
  759.     Swap element 0 and f in array
  760.   */
  761.   sv=p->item[0]; p->item[0]=p->item[f]; p->item[f]=sv;
  762.   return 1;
  763. }
  764.  
  765. /* Find match to %p in pattern
  766. */
  767. int findprepos (cmd)
  768.     char **cmd;
  769. {
  770.   char *w;
  771.   static char *hard_prep[] = {"on","in","under","from","behind","beside",0};
  772.   SVALUE *v;
  773.   int cnt;
  774.  
  775.   if (gForprepos) {
  776.     v = gForprepos->u.lvalue;
  777.     if ((v != 0) && (v->type == T_POINTER)) return findword(cmd,v);
  778.   }
  779.  
  780.   /* No wordlist sent, use hard coded prepositions and return a string
  781.   */
  782.   w = lookfirst(*cmd); lowercase(w);
  783.   cnt=0; while (hard_prep[cnt]) {
  784.     if (strcmp(w,hard_prep[cnt])==0) {
  785.       getfirst(cmd); /* Skip this word */
  786.       if (gCarg) {
  787.     free_svalue(gCarg->u.lvalue);
  788.     gCarg->u.lvalue->type = T_STRING;
  789.     gCarg->u.lvalue->u.string = string_copy(w);
  790.     gCarg->u.lvalue->string_type = STRING_MALLOC;
  791.     return 1;
  792.       }
  793.     }
  794.     cnt++;
  795.   }
  796.   return 0;
  797. }
  798.  
  799. /* Find match to %o in pattern
  800. */
  801. int findsingle (cmd)
  802.     char **cmd;
  803. {
  804.   if (finditem(cmd,0)) {
  805.     if ((itnumalt()==1) && (gCarg)) {
  806.       free_svalue(gCarg->u.lvalue);
  807.       gCarg->u.lvalue->type = T_OBJECT;
  808.       gCarg->u.lvalue->u.ob=italt(1);
  809.       add_ref(gCarg->u.lvalue->u.ob, "parse_command(%o)");
  810.     }
  811.     return 1;
  812.   }
  813.   return 0;
  814. }
  815.  
  816. /* Get the first parsetype of the pattern
  817. */
  818. int get1ps (parsep, lin, skip)
  819.     char **parsep;
  820.     LVALUE **lin;
  821.     int skip;
  822. {
  823.   char *cod,ch;
  824.   int pt;
  825.   LVALUE *l;
  826.  
  827.   pt=EP; cod=getfirst(parsep); l= *lin;
  828.   ch=cod[0]; if (ch=='%') { ch=tolower(cod[1]); ch=cod[1]; }
  829.   switch (ch) {
  830.   case 'i':pt=IT; break;
  831.   case 'l':pt=US; break;
  832.   case 's':pt=TX; break;
  833.   case 'w':pt=W1; break;
  834.   case 'o':pt=SI; break;
  835.   case 'p':pt=PP; break;
  836.   case 'd':pt=NUM; break;
  837.   case '\'':sscanf(cod,"'%[^\']",gMword); pt=DTX; break;
  838.   case '[':sscanf(cod,"\[%[^\135]",gMword); pt=OTX; /* 135 is oct for ] */
  839.     if (gMword[strlen(gMword)-1]==']') gMword[strlen(gMword)-1]=0;
  840.     break;
  841.   case '/':pt=ALT; break;
  842.   }
  843.   if (gDebug) fprintf(stderr,"(%s,%s,%d,%c)",cod,gMword,pt,ch);
  844.   gCarg=0;
  845.   if ((skip) || (pt==DTX) || (pt==OTX) || (pt==ALT)) return pt;
  846.   if (l != gTopStack) { gForprepos=l; gCarg=l; l++; }
  847.   else { gCarg = 0; gForprepos=0; }
  848.   *lin=l;
  849.   return pt;
  850. }
  851.  
  852. /* Add word to the string that matches the latest %s
  853. */
  854. void addword (d, s)
  855.     char *d;
  856.     char *s;
  857. {
  858.   if ((strlen(d)+strlen(s))<(KLUDGELEN-2)) {
  859.     if (!EMPTY(d)) strcat(d," "); 
  860.     strcat(d,s);
  861.   }
  862.   if (gTxarg) {
  863.     free_svalue(gTxarg->u.lvalue);
  864.     gTxarg->u.lvalue->type = T_STRING;
  865.     gTxarg->u.lvalue->u.string = string_copy(d);
  866.     gTxarg->u.lvalue->string_type = STRING_MALLOC;
  867.   }
  868. }
  869.  
  870. /* Main function, called from interpret.c
  871. */
  872. int parse (cs, ob_or_array, ps, dest_args, num_arg)
  873.     char *cs, *ps;
  874.     struct svalue *ob_or_array, *dest_args;
  875.     int num_arg;
  876. {
  877.   /* Arguments:
  878.      string      Command
  879.      ob/arr      List of accessible objects or recurse start object
  880.      ps         parsepattern
  881.      destargs     lvalues.
  882.      num_arg     Number of lvalues.
  883.      */
  884.   
  885.   int altflag,         /* =1 (true) i altkedja, match har intr{ffat */
  886.   txflag,              /* = 1 om vi adderar text till str{ng */
  887.   ptyp;                /* Parsetype %o %i %l %p %s 'word' [word] / %w */
  888.   
  889.   char *parsep;             /* Parsepattern */
  890.   char *cmd;               /* Command to be parsed */
  891.   char *ops,*ocs;          /* Temporary parse and command */
  892.   char tx_jp[KLUDGELEN];   /* Fill up string for %s */
  893.   LVALUE *l;               /* Argument pointer in dest_args */
  894.   int new_routines();
  895.  
  896.   if (ob_or_array->type == T_OBJECT &&
  897.       (ob_or_array->u.ob->flags & O_DESTRUCTED))
  898.     return 0;
  899.   gDebug = 0;
  900.   if (gDebug) {
  901.     fprintf(stderr,"Hold on to your toes, entering JnAparse. ");
  902.   }
  903.  
  904.  
  905.   /* In mudlib 3.0 we will not have this
  906.   */
  907.   if (cs[0]=='@')
  908.         error("Unsupported @ construct.\n");
  909.  
  910.   ocs = cmd = (char *) string_copy(cs);
  911.   
  912.   /* Get the accessible objects
  913.    */
  914.   if (ob_or_array->type == T_OBJECT) makeobjlist(&gOblist,ob_or_array->u.ob);
  915.   else { /* Copy list of given accessible objects in reverse order */
  916.     VECTOR *v;
  917.     SVALUE *vv;
  918.     int cnt;
  919.     v=ob_or_array->u.vec; italt_new();
  920.     for (cnt=0;cnt<v->size;cnt++) {
  921.       vv = &(v->item[v->size-1-cnt]);
  922.       if (vv->type==T_OBJECT) italt_put(vv->u.ob);
  923.     }
  924.     gOblist=gPobjects; gPobjects=0;
  925.   }
  926.   
  927.   ops = parsep = (char *) string_copy(ps);
  928.   gPobjects=gOblist;
  929.   if (gDebug) fprintf(stderr,"Has made list of Acsobjects. %d \n",itnumalt());
  930.   if (gDebug) fprintf(stderr,"Parsing: %s, with pattern: %s\n",cmd,parsep);
  931.   gPobjects=0;
  932.  
  933.   /* Start parsing
  934.    */
  935.   txflag = -1; gCarg = 0; gTxarg = 0; gTopStack = dest_args + num_arg;
  936.   l = dest_args;
  937.  
  938.   ptyp=get1ps(&parsep,&l,0); /* Get first pattern from parse */
  939.  
  940.   while (ptyp != EP) {
  941.     if (gDebug) fprintf(stderr,"Pattern: %d\n",ptyp);
  942.     altflag=0;
  943.     switch(ptyp) { /* See which pattern type to search for */
  944.  
  945.     case EP: break;
  946.       
  947.     case SI: if (findsingle(&cmd)) altflag=1; /* %o */ break;
  948.     case IT: if (findobject(&cmd)) altflag=1; /* %i */ break;
  949.     case US: if (findplay(&cmd)) altflag=1;   /* %l */ break;
  950.     case PP: if (findprepos(&cmd)) altflag=1; /* %p */ break;
  951.  
  952.     case TX: /* %s */
  953.       txflag=1; strcpy(tx_jp,""); gTxarg=gCarg; altflag=1; 
  954.       break;
  955.       
  956.     case DTX: /* 'word' */
  957.       if (EQ(lowercase(gMword),lowercase(lookfirst(cmd)))) {
  958.     getfirst(&cmd); altflag=1;
  959.       }
  960.       break;
  961.  
  962.     case OTX: /* [word] */
  963.       if (EQ(lowercase(gMword),lowercase(lookfirst(cmd)))) {
  964.     getfirst(&cmd); 
  965.       }
  966.       altflag=1; /* Always take next parsepattern type [word] is opt */
  967.       break;
  968.  
  969.     case ALT: /* / */
  970.       altflag=1; /* Should not be found here, if so skip it */
  971.  
  972.     case W1: /* %w */
  973.       gTxarg=gCarg; strcpy(tx_jp,""); altflag=1;
  974.       addword(tx_jp,getfirst(&cmd));
  975.       break;
  976.  
  977.     case NUM: /* %d */
  978.       if ((altflag=numeric(lookfirst(cmd)))>0) {
  979.     if (gCarg) {
  980.       free_svalue(gCarg->u.lvalue);
  981.       gCarg->u.lvalue->type = T_NUMBER;
  982.       gCarg->u.lvalue->u.number = altflag;
  983.     }
  984.     altflag=1; getfirst(&cmd);
  985.       }
  986.       break;
  987.     }
  988.  
  989.     /* Pattern checked altflag==1 indicates match
  990.     */
  991.     if (altflag) { /* Pattern matched, fetch next and end string input */
  992.       if (ptyp != TX) txflag = -1; /* End string input if not just started */
  993.       ptyp=get1ps(&parsep,&l,0);
  994.       while (ptyp == ALT) { /* Skip left over alternatives */
  995.     ptyp=get1ps(&parsep,&l,1); /* Skip this pattern */
  996.     ptyp=get1ps(&parsep,&l,0); /* Next real pattern or ALT */
  997.       }
  998.     }
  999.     else { /* Pattern did not match */
  1000.       char *a;
  1001.       LVALUE *try;
  1002.       int tmp;
  1003.       a=parsep; try=l;
  1004.       tmp=get1ps(&a,&try,0);
  1005.       if (tmp == ALT) { 
  1006.     ptyp=get1ps(&parsep,&l,0); /* Skip ALT */
  1007.     ptyp=get1ps(&parsep,&l,0); /* Next real pattern or ALT */
  1008.       }
  1009.       else {
  1010.     if (txflag>=0) { /* %s is defined, add word and try pattern again */
  1011.       addword(tx_jp,getfirst(&cmd));
  1012.     }
  1013.     else break; /* Impossible to match pattern, exit */
  1014.       }
  1015.     }
  1016.     
  1017.     if (gDebug) fprintf(stderr,"Pattern, after: %d\n",ptyp);
  1018.   } 
  1019.  
  1020.   /* End of pattern reached, what have got? What is left?
  1021.   */
  1022.   if (gDebug) fprintf(stderr,"Pattern ended\n");
  1023.  
  1024.   if (txflag>=0) { /* It ended with a %s, fill up the string */
  1025.     while (!EMPTY(cmd)) addword(tx_jp,getfirst(&cmd));
  1026.   }
  1027.  
  1028.   if (!EMPTY(cmd)) ptyp=ALT; /* No match so set ptyp != EP */
  1029.  
  1030.   /* Now clean up our mess, no alloced mem should remain
  1031.   */
  1032.   free(ocs); free(ops);
  1033.   if (gPobjects) italt_new(); /* Free alternate object list */
  1034.   if (gOblist) {
  1035.     gPobjects=gOblist; italt_new(); /* Free list of accessible objects */
  1036.   }
  1037.   if (ptyp==EP) {
  1038.     if (gDebug) fprintf(stderr,"Exiting Jnaparse with match\n");
  1039.     return 1; /* Successfull match */
  1040.   }
  1041.   else {
  1042.     if (gDebug) fprintf(stderr,"Exiting Jnaparse: No match\n");
  1043.     return 0; /* No match */
  1044.   }
  1045. }
  1046.  
  1047. /*
  1048.  
  1049.    End of Parser
  1050.  
  1051. ***************************************************************/
  1052.  
  1053. #endif
  1054.